﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;

namespace Acoris.Foundation
{
    #region 原始代码

    ///// <summary>
    ///// 
    ///// </summary>
    ///// <typeparam name="Token"></typeparam>
    ///// <typeparam name="Function"></typeparam>
    //public abstract class DFA<Token, Function>
    //{
    //    /// <summary>
    //    /// 初始化状态图
    //    /// </summary>
    //    protected abstract void InitalizeState();
    //}

    ///// <summary>
    ///// 表示所有词法标记的基类
    ///// </summary>
    ///// <typeparam name="TokenState">标识词法标记类型的类型</typeparam>
    //public abstract class TokenBase<TokenState> : IEqualityComparer<TokenBase<TokenState>>
    //    where TokenState : IComparable
    //{
    //    TokenState _state;
    //    int _offset;
    //    int _length;
    //    string _source;
    //    bool _stateOpen;
    //    bool _stateClose;

    //    /// <summary>
    //    /// 
    //    /// </summary>
    //    /// <param name="offset"></param>
    //    /// <param name="length"></param>
    //    /// <param name="source"></param>
    //    protected TokenBase(TokenState state, int offset, int length, string source)
    //    {
    //        _offset = offset;
    //        _length = length;
    //        _source = source;
    //        _state = state;
    //    }

    //    /// <summary>
    //    /// 
    //    /// </summary>
    //    public TokenState State {
    //        get {
    //            return _state;
    //        }
    //    }

    //    /// <summary>
    //    /// 
    //    /// </summary>
    //    public bool StateOpen {
    //        get {
    //            return _stateOpen;
    //        }
    //        set {
    //            _stateOpen = value;
    //        }
    //    }

    //    public int Length {
    //        get {
    //            return _length;
    //        }
    //        set {
    //            _length = value;
    //        }
    //    }

    //    /// <summary>
    //    /// 
    //    /// </summary>
    //    public bool StateClose {
    //        get {
    //            return _stateClose;
    //        }
    //        set {
    //            _stateClose = value;
    //        }
    //    }

    //    #region IEqualityComparer<TokenBase<TokenState>>接口成员

    //    public bool Equals(TokenBase<TokenState> x, TokenBase<TokenState> y)
    //    {
    //        return x._state.Equals(y._state);
    //    }

    //    public int GetHashCode(TokenBase<TokenState> obj)
    //    {
    //        return obj.GetHashCode();
    //    }

    //    #endregion

    //    /// <summary>
    //    /// 
    //    /// </summary>
    //    /// <returns></returns>
    //    public string GetString()
    //    {
    //        return _source.Substring(_offset, _length);
    //    }

    //    public override int GetHashCode()
    //    {
    //        return base.GetHashCode() ^ _state.GetHashCode();
    //    }

    //    /// <summary>
    //    /// 
    //    /// </summary>
    //    /// <returns></returns>
    //    public override string ToString()
    //    {
    //        return $"{_state.ToString()},{_source.Substring(_offset,_length)}";
    //    }
    //}

    ///// <summary>
    ///// 
    ///// </summary>
    ///// <typeparam name="TokenFunction"></typeparam>
    //public class DFAState<TokenFunction> : IDictionary<WordType, DFAState<TokenFunction>>
    //{

    //    //---------------------------------------------------------------------------------------------------
    //    //  DFAState应包含:
    //    //  1) 当前状态标识
    //    //  2) 后继状态字典，通过WordType作为Key
    //    //  3) 包含状态转移可以执行的方法
    //    //---------------------------------------------------------------------------------------------------
    //    int _stateID;
    //    TokenFunction _function;
    //    Dictionary<WordType,DFAState<TokenFunction>> _nextState;

    //    /// <summary>
    //    /// 
    //    /// </summary>
    //    /// <param name="stateID"></param>
    //    /// <param name="token"></param>
    //    /// <param name="action"></param>
    //    public DFAState(int stateID)
    //    {
    //        _stateID = stateID;
    //        _nextState = new Dictionary<WordType, DFAState<TokenFunction>>();
    //    }

    //    /// <summary>
    //    /// 
    //    /// </summary>
    //    /// <param name="word"></param>
    //    /// <param name="state"></param>
    //    public void AddState(WordType word, DFAState<TokenFunction> state)
    //    {
    //        if (_nextState.ContainsKey(word)) {
    //            throw new ArgumentException("已存在关键字");
    //        }
    //        _nextState.Add(word, state);
    //    }

    //    #region IDictionary<WordType,DFAState<TokenFunction>>接口成员

    //    public bool ContainsKey(WordType key)
    //    {
    //        return ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).ContainsKey(key);
    //    }

    //    public void Add(WordType key, DFAState<TokenFunction> value)
    //    {
    //        ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).Add(key, value);
    //    }

    //    public bool Remove(WordType key)
    //    {
    //        return ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).Remove(key);
    //    }

    //    public bool TryGetValue(WordType key, out DFAState<TokenFunction> value)
    //    {
    //        return ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).TryGetValue(key, out value);
    //    }

    //    public void Add(KeyValuePair<WordType, DFAState<TokenFunction>> item)
    //    {
    //        ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).Add(item);
    //    }

    //    public void Clear()
    //    {
    //        ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).Clear();
    //    }

    //    public bool Contains(KeyValuePair<WordType, DFAState<TokenFunction>> item)
    //    {
    //        return ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).Contains(item);
    //    }

    //    public void CopyTo(KeyValuePair<WordType, DFAState<TokenFunction>>[] array, int arrayIndex)
    //    {
    //        ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).CopyTo(array, arrayIndex);
    //    }

    //    public bool Remove(KeyValuePair<WordType, DFAState<TokenFunction>> item)
    //    {
    //        return ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).Remove(item);
    //    }

    //    public IEnumerator<KeyValuePair<WordType, DFAState<TokenFunction>>> GetEnumerator()
    //    {
    //        return ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).GetEnumerator();
    //    }

    //    IEnumerator IEnumerable.GetEnumerator()
    //    {
    //        return ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).GetEnumerator();
    //    }

    //    #endregion

    //    #region Property


    //    /// <summary>
    //    /// 
    //    /// </summary>
    //    public TokenFunction Action {
    //        get {
    //            return _function;
    //        }
    //        set {
    //            _function = value;
    //        }
    //    }

    //    /// <summary>
    //    /// 
    //    /// </summary>
    //    public int Id {
    //        get {
    //            return _stateID;
    //        }
    //    }

    //    public ICollection<WordType> Keys { get => ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).Keys; }
    //    public ICollection<DFAState<TokenFunction>> Values { get => ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).Values; }
    //    public int Count { get => ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).Count; }
    //    public bool IsReadOnly { get => ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState).IsReadOnly; }

    //    public DFAState<TokenFunction> this[WordType key] {
    //        get {
    //            if (this._nextState.ContainsKey(key)) {
    //                return this._nextState[key];
    //            }
    //            return null;
    //        }
    //        set {
    //            ((IDictionary<WordType, DFAState<TokenFunction>>)this._nextState)[key] = value;
    //        }
    //    }

    //    #endregion
    //}

    #endregion
}